
Vue.component2('a_1_0_2_0_0_lines', {  
    template: `
        <div :class="{ 'a_1_0_2_0_0_lines test': data.true, 'a_1_0_2_0_0_lines_onclick': data.onclick_flag }" class="" @click="handle_click" v-show="show_flag">
        <span class="a_1_0_2_0_0_hid_line":style="'padding-left: '+data._space_+'px;'"></span>
        <span  v-if="data.icon1_show_flag":class="{'icon iconfont':data.true,'icon-right':data.close,'icon-down':data.close==false}"></span>
        
        <span style="color:#bcbcbc">{{data.name}}</span>
        </div>
`,
data(){
    return{
        show_flag:true,
        data:{
            onclick_flag:false,
            icon1_show_flag:true,
            click:null,
            click_obj:null,
            true:true,
            false:false,
            close:true,
            name:"",
            _space_:0,
        }
    }
},
methods:{
    handle_click:function(event){
        //点击当前 高亮显示
        try{//console.log("高亮",this.data.path);
this.data.tree_data.set_onclick_flag(this.data.path)}catch{}
        if (this.data.click){
            try{
                this.data.click(event)
                
                // console.log("start click2")
            }
            catch{}
            return 
        }
        if (this.data.click_obj){
            try{
                lhp_run_func(this.data.click_obj.func,this.data.click_obj.args)
            
                // console.log("start click3")
            }
            catch{}
            return 
        }
        try{
            this.data.click_handle(this.data.path,this.data.close);
        }catch{}
    }
}})
//计时器
window.a_1_0_2_0_0_timer=null;
//待处理数据列表
window.a_1_0_2_0_0_timer_lst=[];
//计时器运行函数
window.a_1_0_2_0_0_timer_func= async function(){
    while(window.a_1_0_2_0_0_timer_lst.length){
        let new_obj=window.a_1_0_2_0_0_timer_lst.shift();
        let func=new_obj.func;
        if(func.constructor.name === 'AsyncFunction'){
            await func(new_obj.params);
        } else{
            func(new_obj.params);
        }
    }
    window.a_1_0_2_0_0_timer=null;
};
//给计数器运行的函数添加待处理数据  如果计时器没有开启则开启计时器
window.a_1_0_2_0_0_timer_start=function(obj) {  
    window.a_1_0_2_0_0_timer_lst.push(obj);
    if(window.a_1_0_2_0_0_timer==null){

        window.a_1_0_2_0_0_timer = setTimeout(a_1_0_2_0_0_timer_func, 0);    // 设置计时器为开启状态  
    }
}  
Vue.component2('a_1_0_2_0_0', {  
    template: `
        <div class="a_1_0_2_0_0_base" ref="father"v-show="data.show_flag">
        </div>
`,  
  data() {
      return {
        show_index:'-1',
        callback:"",
        init_flag:0,
        now_select:"-1",
        refresh:"1",/*用来刷新组件*/
        data:{
            tree_data:{check_dct:{}},//数据会传递给所有子节点的vue对象.data.tree_data中
            show_flag:true,
            data:{},
            data_init:false,
            close:true,
            fast_data:{}, //快速访问dom
            fast_vue_data:{},//快速访问vue
            open_dict:{},//节点展开的状态保存
            open_dict_init:false,//open_dict初始化
            // {
            //     0:{
            //         close:true,
                        // open_num:
            //         dict:{

            //         }
            //     }
            
            // }
            
        },
      };
  },
  methods:{
    //添加进时间处理器中 同步进行处理
    add_timer:function(){},
    insertAfter:function(newNode, referenceNode, parentNode) {  
        if(referenceNode==parentNode){
            parentNode.appendChild(newNode);  
            return
        }
        // 将 newNode 插入到 referenceNode 之后  
        if (referenceNode.nextSibling) {  
            // /* console.log("?")*/
            parentNode.insertBefore(newNode, referenceNode.nextSibling);  
        } else {  
            //如果是最后一个子节点 则追加
            let father_child_lst=parentNode.children;
            if (father_child_lst[father_child_lst.length-1]===referenceNode){
                parentNode.appendChild(newNode);
                return
            }
            //否则插入
            // 获取父元素的第一个子节点  
            let firstChild = parentNode.firstChild;  
              
            // 在第一个子节点之前插入新节点  
            if (firstChild) {  
                parentNode.insertBefore(newNode, firstChild);  
                // parentNode.appendChild(newNode);  
            } else {  
                // 如果没有子节点，直接添加新节点  
                parentNode.appendChild(newNode);  
            }
        }  
    },
    handle_click:function(event,flag=null){

      // event.target 是触发点击事件的元素  
      let clickedElement = event.target;  
      if(!flag){event.stopPropagation();}//阻止父级
    }
  },
  mounted:function(){
    window['dddd']=_this
    _this.wait_run_func_class_obj=new wait_run_func_class();
    console.log("_this.deepcopy_data.tree_data.",_this.deepcopy_data,_this.deepcopy_data.tree_data);
    if(!_this.deepcopy_data.tree_data){
        _this.deepcopy_data.tree_data={check_dct:{}};
    }
    _this.deepcopy_data.tree_data.get_father=function(){
        return _this.data
    }
    _this.deepcopy_data.tree_data.change_deepcopy_data=function(path,copy_data){
        if(!copy_data){console.log("修改参数失败，传参异常",path,copy_data)
}
        let path_lst=path.split(".");
        let data=_this.data.data;
        for(let i=0;i<path_lst.length;i++){
            data=data.dict[path_lst[i]];
        }
        lhp_deepcopy1(data.base_info.deepcopy_data,copy_data);
        try{lhp_deepcopy1(_this.data.fast_vue_data[path].$refs.ref_obj.data,copy_data)}catch{}
    }
    _this.del_data=function(path){
        let path_lst=path.split(".");
        let last_k=path_lst[path_lst.length-1];
        let del_data=_this.data.data;
        // console.log("del_data1",del_data)
        for(let i=0;i<path_lst.length-1;i++){
            del_data=del_data.dict[path_lst[i]];
            // console.log("del_data1",del_data)
        }

        console.log("del_data2",del_data,last_k)
        delete del_data.dict[last_k];
    }
    _this.deepcopy_data.tree_data.del_path=function(path){
        let ddd=path;
//如果处于展开状态 那么关闭展开
        let now_open_dict=_this.data.get_now_open_dict(ddd);
        
        if(now_open_dict.close==false){
            _this.data._close(ddd);
        }   
//如果存在快速访问方式 那么删除快速访问
if (_this.data.fast_data[ddd]){
    try{
        console.log("del ddd",ddd)
        let open_del=_this.data.open_dict;
        let d_path_lst=ddd.split(".");
        for (let i9=0;i9<d_path_lst.length-1;i9++){open_del=open_del[d_path_lst[i9]]}
        delete open_del[d_path_lst[d_path_lst.length-1]];
        _this.$refs.father.removeChild(_this.data.fast_data[ddd]);
        delete _this.data.fast_data[ddd];
        delete _this.data.fast_vue_data[ddd];
    }catch{}

}
//删除数据
_this.del_data(ddd);



    }
    //调用此函数 会对目标vueobj.data.onclick_flag=true; 取消其他高亮
    _this.deepcopy_data.tree_data.set_onclick_flag=function(path){
        //初始化
        // console.log("初始化");
        if(!_this.__onclick_now){_this.__onclick_now='??'}
        //设置上一个高亮为false
        // console.log("取消上一个高亮_this.data.fast_vue_data[_this.__onclick_now].$refs.ref_obj");
        try{_this.data.fast_vue_data[_this.__onclick_now].$refs.ref_obj.data.onclick_flag=false;}catch{}
        //设置当前高亮为true
        // console.log("设置当前为高亮",_this.data.fast_vue_data[path].$refs.ref_obj);window.nnn2=_this.data.fast_vue_data[path].$refs.ref_obj
        _this.__onclick_now=path;
        _this.data.fast_vue_data[path].$refs.ref_obj.data.onclick_flag=true;
    }
    _this.set_open_dict=function(dict,path){
        let  open_dict= _this.data.open_dict;
        let  copy_dict=_this.data.copy({dict:dict});
        // delete copy_dict.close;
        let path_lst=path.split(".");
        for(let i=0;i<path_lst.length;i++){
            open_dict=open_dict[path_lst[i]];
        }
        let v={};
        for (let k in copy_dict){
            if(open_dict.hasOwnProperty(k)){continue}
            else{
                v[k]=copy_dict[k];
            }
        }
        if(!open_dict.hasOwnProperty('close')){open_dict.close=copy_dict.close}
        open_dict.num=copy_dict.num;
        lhp_deepcopy1(open_dict,v)
    }
    _this.data.get_close=function(path){
        let path_lst=path.split(".");
        let check_open_dct=_this.data.open_dict;
        for(let i=0;i<path_lst.length;i++){
            check_open_dct=check_open_dct[path_lst[i]];
        }
        return check_open_dct.close;
    }
    //获取父节点下上一个子节点的key 没有则返回-In...
    _this.data.get_before=function(father_path,key){
        console.log("father,k",father_path,key)
        let path_lst=father_path.split(".");
        let check_open_dct=_this.data.open_dict;
        for(let i=0;i<path_lst.length;i++){
            check_open_dct=check_open_dct[path_lst[i]];
        }
        let key_v=Number(key);
        let maxIntKey = -Infinity;  
        for (let k in check_open_dct) {  
            if (check_open_dct.hasOwnProperty(k)) {  
                let intKey = Number(k);  
                if (!isNaN(intKey) && intKey < key_v && intKey > maxIntKey) {  
                    maxIntKey = intKey;  
                }  
            }  
        }  
        if (maxIntKey==-Infinity){return -Infinity}
        else{
            return father_path+'.'+maxIntKey;
        }


    }
    //获取到目标节点的最后一个dom
    _this.data.get_last=function(path){
        let path_lst=path.split(".");
        let check_open_dct=_this.data.open_dict;
        for(let i=0;i<path_lst.length;i++){
            check_open_dct=check_open_dct[path_lst[i]];
        }
        let last_path=path;
        while (1){
            if (check_open_dct.close==true){return _this.data.fast_data[last_path]}
            else{
                // 提取并转换所有可以转换为整数的键  
                let intKeys = Object.keys(check_open_dct).filter(key => /^\d+$/.test(key)).map(Number);  
                if(!intKeys.length){return _this.data.fast_data[last_path]}
                let maxIntKey = Math.max(...intKeys);  
                check_open_dct=check_open_dct[maxIntKey];
                last_path=last_path+'.'+maxIntKey;
            }
        }
    }
    _this.data._set_dict=function(obj){
        
        let dict=obj.dict;
       let path=obj.path;
        // console.log("_this.data.get_close(path)",_this.data.get_close(path))
        //加载这部分的this.data.open_dict
        console.log("dict path",dict,path)
        _this.set_open_dict(dict,path);
        //加载这部分内容到this.data.data中
        let path_lst=path.split(".");
        // let last_k=path_lst[path_lst.length-1];
        // let father_path=path.substring(0, path.lastIndexOf('.'));  
        console.log("dict path",dict,path)
        let father_close=_this.data.get_close(path);
        // console.log("_this.data.get_close(path)1",_this.data.get_close(path))
        let set_data=_this.data.data;
        // console.log("_this.data.get_close(path)2",_this.data.get_close(path))
        for(let i=0;i<path_lst.length;i++){
            set_data=set_data['dict'][path_lst[i]];
        }
        // console.log("_this.data.get_close(path)3",_this.data.get_close(path))
        for (let key in dict){
            if(!set_data['dict'][key]){
                // console.log("检测到新增的数据",path+'.'+key)
                set_data['dict'][key]=dict[key]
                // console.log("检测父组件显示状态（显示则为True",!father_close)
                //如果这部分正在显示 那么创建这个dom
                if(!father_close){
                    console.log("dict[key].base_info",dict[key].base_info)
                                let vue_name=dict[key].base_info.vue_name||'a_1_0_2_0_0_lines';//要渲染的vue模板名称
                                //新建一个dom
                                let new_dom=document.createElement(vue_name);
                                //设置dom属性 ref值为ref_obj
                                new_dom.setAttribute('ref', 'ref_obj');
                                let t_deepcopy_data=JSON.parse(JSON.stringify(dict[key].base_info.deepcopy_data));
                                t_deepcopy_data['_space_']=path_lst.length*8;//退格
                                t_deepcopy_data['path']=path+'.'+key;
                                t_deepcopy_data['tree_data']=_this.data.tree_data;
                                t_deepcopy_data['click_handle']=_this.data.click_handle;
                                new_dom.setAttribute(':deepcopy_data',"deepcopy_data");//初始化vue模板的参数
                                new_dom.setAttribute('dom_path',path+'.'+key);//初始化vue模板的参数
                                let vue_dct={'el':new_dom,data:{true:true,false:false,null:null,deepcopy_data:t_deepcopy_data}}
                                let before_path=_this.data.get_before(path,key);
                                console.log("???beforepath",before_path,path,key)
                                if(before_path==-Infinity){
                                    _this.insertAfter(new_dom,_this.data.fast_data[path],_this.$refs.father);
                                }else{
                                    _this.insertAfter(new_dom,_this.data.get_last(before_path),_this.$refs.father);
                                }
                                let new_vue=new Vue(vue_dct);
                                // window.test_vue=new_vue;
                                _this.data.fast_data[path+'.'+key]=new_vue.$el;
                                // next_dom2=new_vue.$el;
                                _this.data.fast_vue_data[path+'.'+key]=new_vue;
                }
            }else{
                // console.log("没有新增数据",path+'.'+key)
                // console.log("检测父组件显示状态（显示则为True",!father_close)
                lhp_deepcopy1(set_data['dict'][key]['base_info'],dict[key]['base_info']);
                //如果这部分正在显示 那么更新这个dom
                if(!father_close){
                    //新建一个dom
                    // new_dom=document.createElement(vue_name);
                    // //设置dom属性 ref值为ref_obj
                    // new_dom.setAttribute('ref', 'ref_obj');
                    // t_deepcopy_data['_space_']=path_lst.length*8;//退格
                    // t_deepcopy_data['path']=path;
                    // t_deepcopy_data['tree_data']=_this.data.tree_data;
                    // t_deepcopy_data['click_handle']=_this.data.click_handle;
                    // new_dom.setAttribute(':deepcopy_data',"deepcopy_data");//初始化vue模板的参数
                    // new_dom.setAttribute('dom_path',path+'.'+key);//初始化vue模板的参数
                    // let vue_dct={'el':new_dom,data:{true:true,false:false,null:null,deepcopy_data:t_deepcopy_data}}
                    // if(key==1){
                    //     _this.insertAfter(new_dom,_this.data.fast_data[path],_this.$refs.father);
                    // }else{
                    //     _this.insertAfter(new_dom,_this.data.fast_data[path+'.'+(Number(key)-1)],_this.$refs.father);
                    // }
                    // new_vue=new Vue(vue_dct);
                    // // window.test_vue=new_vue;
                    // _this.data.fast_data[path+'.'+key]=new_vue.$el;
                    // // next_dom2=new_vue.$el;
                    // _this.data.fast_vue_data[path+'.'+key]=new_vue;
                    
                }
            }
        }

        // console.log("_this.data.get_close(path)4",_this.data.get_close(path))
    }
    _this.data.set_dict=function(dict,path){
        
    console.log("?12")
        _this.wait_run_func_class_obj.timer_start({
            func:_this.data._set_dict,
            params:{
                dict:dict,
                path:path
            }
        })
       
    console.log("?22")
    }
    _this.deepcopy_data.tree_data.set_dict=_this.data.set_dict;
    _this.data.show_index_callback=function(index){
        if(index==_this.show_index){
            _this.data.show_flag=true;
            if(_this.data.data_init==false){
                _this.data.data_init=true;
                // console.log("init!!!")
                _this.data.open("");
            }
        }else{_this.data.show_flag=false}
    }
    _this.data.set_show_index=function(show_index){
        _this.show_index=show_index;
    }
  //初始化
  _this.init=function(){
    _this.data.open('');
    _this.init_flag=1;
  }
  _this.data.click_handle=async function(path,close_flag){
    if(close_flag==true){
       await _this.data.open(path);
    }else{
        await _this.data.close(path);
    }
  }
  //展开
  _this.data.set_open=function(__this){
    // console.log("设置为展开",__this)
    __this.$refs.ref_obj.data.close=false;
  }
  //闭合
  _this.data.set_close=function(__this){
    __this.$refs.ref_obj.data.close=true;
  }
  _this.data.copy=function(copy_data){
    let res={};
    let lst=[[copy_data,res]];
    while (lst.length){
        let item=lst.pop();
        let new_data=item[0];
        let new_res=item[1];
        new_res.close=true;
        if (new_data.dict){
            // console.log("...")
            new_res.num=Object.keys(new_data.dict).length+1;
            for (let key in new_data.dict){
                new_res[key]={};
                new_res2=new_res[key];
                lst.push([
                    new_data.dict[key],
                    new_res2

                ])
            }
        }else{
            new_res.num=1;
        }
    }
    // console.log("end")
    return res
  }
  _this.sleep=function sleep(ms) {  
    return new Promise(resolve => setTimeout(resolve, ms));  
}  
_this.data.check_variable=function(variable, keyOrIndex) {  
    // 判断是数组还是对象  
    if (Array.isArray(variable)) {  
        // 如果是数组，判断索引是否存在  
        if (variable.hasOwnProperty(keyOrIndex.toString()) && Number.isInteger(Number(keyOrIndex))) {  
            // console.log(`索引 ${keyOrIndex} 存在于数组中`);  
            return 1
        } else {  
            // console.log(`索引 ${keyOrIndex} 不存在于数组中`);  
            return 2
        }  
    } else if (variable && typeof variable === 'object' && !Array.isArray(variable)) {  
        // 如果是对象，判断键是否存在  
        if (variable[keyOrIndex]) {  
            // console.log(`键 "${keyOrIndex}" 存在于对象中`);  
            return 3
        } else {  
            // console.log(`键 "${keyOrIndex}" 不存在于对象中`);  
            return 4
        }  
    } else {  
        // console.log('变量既不是数组也不是对象');  
    }  
}  
_this.data.isPlainObject=function(variable) {  
    return variable !== null &&  
           typeof variable === 'object' &&  
           !Array.isArray(variable) &&  
           Object.getPrototypeOf(variable) === Object.prototype;  
} 
function removeLastDotAndAfter(str) {  
    // 找到最后一个点的索引位置  
    let lastIndex = str.lastIndexOf('.');  
      
    // 如果找到了点，则截取点到字符串开头之间的部分  
    if (lastIndex !== -1) {  
        return str.substring(0, lastIndex);  
    }  
      
    // 如果没有找到点，则返回原始字符串  
    return str;  
}  
function splitByLastDot(str) {  
    // 查找最后一个点的索引位置  
    const lastIndex = str.lastIndexOf('.');  
  
    // 根据索引位置分割字符串  
    if (lastIndex !== -1) {  
        // 如果有点，返回分割后的两部分  
        return [str.slice(0, lastIndex), str.slice(lastIndex+1)];  
    } else {  
        // 如果没有点，返回原始字符串和一个空字符串  
        return [str, ''];  
    }  
} 
_this.data.get_now_open_dict=function(path){
    
    let now_open_dict=_this.data.open_dict;
    path=removeLastDotAndAfter(path);

    let new_p=path.replace(/dict./g,"").replace(/data./g,"");
    if (new_p.endsWith('.dict')) {  
        new_p=new_p.slice(0, -5);  
    }  
    let new_p_lst=new_p.split(".");
    // console.log("open_dict",JSON.parse(JSON.stringify(_this.data.open_dict)))
    // console.log("new_p_lst",new_p_lst)
    for(let new_p_i=0;new_p_i<new_p_lst.length;new_p_i++){
        now_open_dict=now_open_dict[new_p_lst[new_p_i]];
    }
    return now_open_dict;
}
_this.data.get_now_open_dict2=function(new_p_lst){
    
    let now_open_dict=_this.data.open_dict;
    for(let new_p_i=0;new_p_i<new_p_lst.length-1;new_p_i++){
        now_open_dict=now_open_dict[new_p_lst[new_p_i]];
    }
    return now_open_dict;
}
_this.lhp_set1=function(obj_){
    let data_type=obj_.data_type;//要修改的数据类型  post||put delete clear
    // let _this=obj_._this;//this vue对象
    let path=obj_.path;//path为data_obj要修改的数据的路径
    let data=obj_.data;//data为修改的数据
    console.log("lhp_set1",obj_)
    //类型为新增或者修改
    if (data_type=='postput'){
    let change_obj=_this.data;
    let last_path=null;
    if (path.indexOf(".") !== -1){
        let path_lst=path.split(".");
        for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
        last_path=path_lst[path_lst.length-1];
    }else{last_path=path}
    // console.log("change_obj",change_obj)
    // console.log("last_path",last_path)
    if(_this.data.isPlainObject(change_obj)){
        if(change_obj.hasOwnProperty(last_path)){
            lhp_deepcopy1(change_obj[last_path],JSON.parse(JSON.stringify(data)));

        }else{
            change_obj[last_path]=JSON.parse(JSON.stringify(data));
        }
    }else if(isArray(change_obj)){
        if(change_obj[last_path]!=undefined){
            lhp_deepcopy1(change_obj[last_path],JSON.parse(JSON.stringify(data)));
        }else{
            change_obj[last_path]=JSON.parse(JSON.stringify(data));
        }
    }
    // console.log("path",path)
    // console.log("_this.$set(change_obj,last_path,data)",change_obj,last_path,data)
    // lhp_deepcopy1(change_obj,JSON.parse(JSON.stringify(data)));
    //类型为删除
    }else if(data_type=="delete"){
        let change_obj=_this.data.data;
        let father_idx=null;
        let father_obj=null;
        if (path.indexOf(".") !== -1){
            let path_lst=path.split(".");
            if (path_lst.length<=1){console.log("delete异常 数量小于等于1");
return}
            for (let i=0;i<path_lst.length-1;i++){father_obj=change_obj;father_idx=path_lst[i];change_obj=change_obj[path_lst[i]];}
            let last_idx=path_lst[path_lst.length-1];
            // let new_data=JSON.parse(JSON.stringify(change_obj));
            if(typeof change_obj =="object") {  
                if (Array.isArray(change_obj)){
                    change_obj.splice(last_idx,1);

                }else{
                    delete change_obj[last_idx];
                }
        }}else{console.log("delete异常 数量小于2");
return}

        
//类型为清空数据
}else if(data_type=="clear"){
    let change_obj=_this.data;
    let last_key=null;
    if (path.indexOf(".") !== -1){
        let path_lst=path.split(".");
        for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
        last_key=path_lst[path_lst.length-1];
    }else{
        last_key=path;
    
    }
    let temp_val=change_obj[last_key]
switch (typeof temp_val) {  
        case 'object':  
            // 注意：这里会匹配到null，因为null也是object类型  
            // 需要额外检查是否为null  
            if (temp_val === null) {  
                change_obj[last_key] = null; // 或者你可以将null也设置为{}  
            } else if (Array.isArray(temp_val)) {  
                change_obj[last_key] = [];  
            } else {  
                change_obj[last_key] = {};  
            }  
            break;  
        case 'string':  
        change_obj[last_key] = '';  
            break;  
        case 'number':  
        change_obj[last_key] = 0;  
            break;  
        case 'boolean':  
        change_obj[last_key] = false;  
            break;  

}


}else if(data_type=='insert'){
    // let before_idx=obj_.before_idx;
    let change_obj=_this.data;
    // let last_path=null;
    // console.log("insert检查-1 obj_",obj_)
    // console.log("insert检查 前data",JSON.parse(JSON.stringify(_this.data.data)))
    if (path.indexOf(".") !== -1){
        let path_lst=path.split(".");
        for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
        last_path=path_lst[path_lst.length-1];
    }else{last_path=path}
    change_obj[last_path]=JSON.parse(JSON.stringify(data));
    //类型为删除
    }
}

// 示例数组
// let array = ["123", "abc", "456", "def", "789", "ghi", 0, "0", " "];
 
// 使用 filter 方法过滤非数字的字符串
let filteredArray = function(array){
    let res=[];
    for(let i=0;i<array.length;i++){
        try{
            let val=Number(array[i])+'';
            if (val!='NaN'){
                res.push(Number(array[i])+'');
            }
        }catch{}
    }
    return res
}
// console.log(filteredArray); // 输出: [123, 456, 789, 0]
//接收协同数据更改后 创建open_dict临时变量 以及打开当前已经显示的数据
_this.data._add_open_dict_and_open=function(obj_){
    let ttt=new Date().getTime();
    // console.log(">>>>????FFFF")
    let data_type=obj_.data_type;//要修改的数据类型  post||put delete clear
    let _this=obj_._this;//this vue对象
    let path=obj_.path;//path为data_obj要修改的数据的路径
    let data=obj_.data;//data为修改的数据
    let path_lst=path.split(".");
    let new_path=filteredArray(path_lst);
    let ddd=new_path.join(".");
    // let last_str=path_lst[path_lst.length-1];
    //类型为新增或者修改
    if (data_type=='postput'){
        _this.lhp_set1(obj_);
        // console.log(">>>>>>????fffff2222",path)
        //检查是否属于添加新的项
        if(path_lst[path_lst.length-2]=='dict'){
            // console.log("pathlsssst",path_lst,new_path)
            let last_idx=new_path[new_path.length-1];
            //生成的open_dict
            let now_open_dict=_this.data.get_now_open_dict2(new_path);
            // console.log("now_open_dicteeeeeeeeee",now_open_dict,last_idx,data,_this.data.copy(data))
            //检查当前树是否拥有此open_dict
            if(!now_open_dict[last_idx]){
                //将生成的open_dict加载到当前树中
                now_open_dict[last_idx]=_this.data.copy(data);
                //检查上层是否是打开状态  如果是打开状态 那么打开当前层
                if(now_open_dict.close!=true){
                    let vue_name=data.base_info.vue_name||'a_1_0_2_0_0_lines';//要渲染的vue模板名称
                    //新建一个dom
                    let new_dom=document.createElement(vue_name);
                    //设置dom属性 ref值为ref_obj
                    new_dom.setAttribute('ref', 'ref_obj');
    // console.log("??key??!2")
                    let t_deepcopy_data=JSON.parse(JSON.stringify(data.base_info.deepcopy_data));
                    t_deepcopy_data['_space_']=(new_path.length-1)*8;//退格
                    t_deepcopy_data['path']=ddd;
                    t_deepcopy_data['tree_data']=_this.data.tree_data;
                    t_deepcopy_data['click_handle']=_this.data.click_handle;
                    new_dom.setAttribute(':deepcopy_data',"deepcopy_data");//初始化vue模板的参数
                    new_dom.setAttribute('dom_path',ddd);//初始化vue模板的参数
                    let vue_dct={'el':new_dom,data:{true:true,false:false,null:null,deepcopy_data:t_deepcopy_data}}
                    let pathxx=splitByLastDot(ddd);
                    let before_path=_this.data.get_before(...pathxx);
    // console.log("??key??!3")
                    // console.log("???beforepath",before_path,path,key)
                    if(before_path==-Infinity){
                        _this.insertAfter(new_dom,_this.data.fast_data[pathxx[0]],_this.$refs.father);
                    }else{
                        _this.insertAfter(new_dom,_this.data.get_last(before_path),_this.$refs.father);
                    }
                    // console.log("??key??!2")
                    let new_vue=new Vue(vue_dct);
                    // window.test_vue=new_vue;
                    _this.data.fast_data[ddd]=new_vue.$el;
                    // next_dom2=new_vue.$el;
                    _this.data.fast_vue_data[ddd]=new_vue;
                }
            }
            return
        }
        //检查是否时更改组件内容
        if(path_lst[path_lst.length-1]=='deepcopy_data'){
                let path_lst2=ddd.split(".");
                let now_set_obj=_this.data.tree_data.全局配置对象.update_obj.data[_this.data['config_name']];
                // let now_set_obj=_this.data.data;
                for(let i=0;i<path_lst2.length;i++){
                    now_set_obj=now_set_obj['dict'][path_lst2[i]];
                }
                try{_this.data.fast_vue_data[ddd].$refs['ref_obj'].init_val()}catch{}
                lhp_deepcopy1(_this.data.fast_vue_data[ddd].$refs['ref_obj'].data,JSON.parse(JSON.stringify(now_set_obj.base_info.deepcopy_data)));
            return
        }


    let change_obj=_this.data;
    let last_path=null;
    if (path.indexOf(".") !== -1){

        for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
        last_path=path_lst[(path_lst.length-1)];
    }else{last_path=path}
    // let select=_this.data.check_variable(change_obj,last_path);
    // console.log("检查这条数据 如果数据线内有数据)不存于open_dict那么,_this.data.isPlainObject(change_obj[last_path])",_this.data.isPlainObject(change_obj[last_path]))
    //检查这条数据 如果数据线内有数据)不存于open_dict那么
        if(_this.data.isPlainObject(change_obj[last_path])){
            let dict_flag=false;
           if (change_obj[last_path].hasOwnProperty('dict')){
            dict_flag=true;
            // _this.data._set_dict({
            //     dict:change_obj[last_path].dict,
            //     path:path.replace("data.","").replace("dict.","").replace(".dict","")
            // })
            // console.log("data1")
            let copy_open_dict={};
            if (last_path=='data'){return}
            copy_open_dict[last_path]=_this.data.copy(change_obj[last_path]);
            let now_open_dict=_this.data.get_now_open_dict(path);
            // console.log("now_open_dict",now_open_dict)
            // console.log("copy_open_dict",copy_open_dict)
            lhp_deepcopy1(now_open_dict,copy_open_dict);
            // console.log("startx",now_open_dict.close)
            if(now_open_dict.close==false){
                let ddd=path.replace(/data./g,"").replace(/dict./g,"").replace(/.dict/g,"");
                let path_lst=ddd.split(".");
                let now_set_obj=_this.data.data;
                for(let i=0;i<path_lst.length;i++){
                    now_set_obj=now_set_obj['dict'][path_lst[i]];
                }
                console.log()
                //如果没有被显示
                if  (!_this.data.fast_data.hasOwnProperty(ddd)){
                    console.log("没有显示")
                    // console.log("??key??!1")
                                    let vue_name=now_set_obj.base_info.vue_name||'a_1_0_2_0_0_lines';//要渲染的vue模板名称
                                    //新建一个dom
                                    let new_dom=document.createElement(vue_name);
                                    //设置dom属性 ref值为ref_obj
                                    new_dom.setAttribute('ref', 'ref_obj');
                    // console.log("??key??!2")
                                    let t_deepcopy_data=JSON.parse(JSON.stringify(now_set_obj.base_info.deepcopy_data));
                                    t_deepcopy_data['_space_']=(path_lst.length-1)*8;//退格
                                    t_deepcopy_data['path']=ddd;
                                    t_deepcopy_data['tree_data']=_this.data.tree_data;
                                    t_deepcopy_data['click_handle']=_this.data.click_handle;
                                    new_dom.setAttribute(':deepcopy_data',"deepcopy_data");//初始化vue模板的参数
                                    new_dom.setAttribute('dom_path',ddd);//初始化vue模板的参数
                                    let vue_dct={'el':new_dom,data:{true:true,false:false,null:null,deepcopy_data:t_deepcopy_data}}
                                    let pathxx=splitByLastDot(ddd);
                                    let before_path=_this.data.get_before(...pathxx);
                    // console.log("??key??!3")
                                    // console.log("???beforepath",before_path,path,key)
                                    if(before_path==-Infinity){
                                        _this.insertAfter(new_dom,_this.data.fast_data[pathxx[0]],_this.$refs.father);
                                    }else{
                                        _this.insertAfter(new_dom,_this.data.get_last(before_path),_this.$refs.father);
                                    }
                                    // console.log("??key??!2")
                                    let new_vue=new Vue(vue_dct);
                                    // window.test_vue=new_vue;
                                    _this.data.fast_data[ddd]=new_vue.$el;
                                    // next_dom2=new_vue.$el;
                                    _this.data.fast_vue_data[ddd]=new_vue;
                                    // console.log("??key??!3")


                }

                                   
    }


}

        if(dict_flag==false){
            if(last_path=='deepcopy_data'){
                // console.log("开始处理deepcopy数据")
                let ddd=path.replace(/data./g,"").replace(/dict./g,"").replace(/.dict/g,"").replace(".base_info.deepcopy_data",'');
                console.log("ddd",ddd)
                let path_lst=ddd.split(".");
                let now_set_obj=_this.data.data;
                for(let i=0;i<path_lst.length;i++){
                    now_set_obj=now_set_obj['dict'][path_lst[i]];
                }
                // console.log("_this.data.fast_vue_data[ddd]",_this.data.fast_vue_data[ddd]);
                // console.log("JSON.parse(JSON.stringify(now_set_obj.base_info.deepcopy_data))",JSON.parse(JSON.stringify(now_set_obj.base_info.deepcopy_data)))
                lhp_deepcopy1(_this.data.fast_vue_data[ddd].$refs['ref_obj'].data,JSON.parse(JSON.stringify(now_set_obj.base_info.deepcopy_data)));
        // ttime3(_this.data.fast_vue_data[path],'ref_obj',,func2_lst=[]);//拷贝数据到vue对象内
            }
        }
        }else{
        }

    //检查这条数据 将本该展开的部分展开

    // //检查这条数据 将已展开的且拥有更新deepcopy_data选项全部更新到节点
    


    // lhp_deepcopy1(change_obj[last_path],JSON.parse(JSON.stringify(data)));
    //类型为删除
    }else if(data_type=="delete"){
        try{
            let ddd=path.replace(/data./g,"").replace(/dict./g,"").replace(/.dict/g,"");
            //如果处于展开状态 那么关闭展开
                let change_obj=_this.data;
                let last_path=null;
                if (path.indexOf(".") !== -1){
                    let path_lst=path.split(".");
                    for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
                    last_path=path_lst[(path_lst.length-1)];
                }else{last_path=path}
                //检查是否是对象
                if(_this.data.isPlainObject(change_obj[last_path])){
                    let dict_flag=false;
                   if (change_obj[last_path].hasOwnProperty('dict')){
                    dict_flag=true;
                    let now_open_dict=_this.data.get_now_open_dict(path);
                    
                    if(now_open_dict.close==false){
                        _this.data._close(ddd);
            }
            
            
            }
            
            }  
            //如果存在快速访问方式 那么删除快速访问
            if (_this.data.fast_data[ddd]){
                try{
                    console.log("del ddd",ddd)
                    let open_del=_this.data.open_dict;
                    let d_path_lst=ddd.split(".");
                    for (let i9=0;i9<d_path_lst.length-1;i9++){open_del=open_del[d_path_lst[i9]]}
                    delete open_del[d_path_lst[d_path_lst.length-1]];
                    _this.$refs.father.removeChild(_this.data.fast_data[ddd]);
                    delete _this.data.fast_data[ddd];
                    delete _this.data.fast_vue_data[ddd];
                }catch{}
            
            }
            //删除数据
            _this.lhp_set1(obj_);
            
            
        }catch (err){
console.log("err",err)
        }
    
//类型为清空数据
}else if(data_type=="clear"){
    _this.lhp_set1(obj_);
    if(path_lst[path_lst.length-1]=='info'){
        let objxxx=_this.data.fast_vue_data[ddd].$refs['ref_obj'].data.info;

        // console.log("######objxxx######### 111",JSON.parse(JSON.stringify(objxxx)))
        for (let key in objxxx) {
            if (objxxx.hasOwnProperty(key) && key !== 'version') {
            delete objxxx[key];
            }
        }
        // console.log("######objxxx######### 222",JSON.parse(JSON.stringify(objxxx)))
    return
}
    return
    let change_obj=_this.data.data;
    let last_key=null;
    if (path.indexOf(".") !== -1){
        let path_lst=path.split(".");
        for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
        last_key=path_lst[path_lst.length-1];
    }else{
        last_key=path;
    
    }
    let temp_val=change_obj[last_key]
switch (typeof temp_val) {  
        case 'object':  
            // 注意：这里会匹配到null，因为null也是object类型  
            // 需要额外检查是否为null  
            if (temp_val === null) {  
                change_obj[last_key] = null; // 或者你可以将null也设置为{}  
            } else if (Array.isArray(temp_val)) {  
                change_obj[last_key] = [];  
            } else {  
                change_obj[last_key] = {};  
            }  
            break;  
        case 'string':  
        change_obj[last_key] = '';  
            break;  
        case 'number':  
        change_obj[last_key] = 0;  
            break;  
        case 'boolean':  
        change_obj[last_key] = false;  
            break;  

}


}else if(data_type=='insert'){
    // let before_idx=obj_.before_idx;
    let change_obj=_this.data.data;
    // let last_path=null;
    // console.log("insert检查-1 obj_",obj_)
    // console.log("insert检查 前data",JSON.parse(JSON.stringify(_this.data.data)))
    if (path.indexOf(".") !== -1){
        let path_lst=path.split(".");
        for (let i=0;i<path_lst.length-1;i++){change_obj=change_obj[path_lst[i]]}
        last_path=path_lst[path_lst.length-1];
    }else{last_path=path}
    change_obj[last_path]=JSON.parse(JSON.stringify(data));
    //类型为删除
    }
    console.log("更新_add_open_dict_and_open耗时:",(new Date().getTime()-ttt)/1000)
}
_this.data.add_open_dict_and_open=function(obj_){
    _this.data._add_open_dict_and_open(obj_);
}
  //点击
  //展开目录

  _this.data._open=async function(path){
    
    //初始化节点的打开信息 以及当前节点的打开数量
    if (_this.data.open_dict_init==false){
        //初始化父节点到快速查找对象中
        _this.data.fast_data[null]=_this.$refs.father;
        _this.data.fast_data['']=_this.$refs.father;
        _this.data.open_dict=_this.data.copy(_this.data.data)//初始化父dom到快速查找字典中
        _this.data.open_dict_init=true;
        // console.log("open_dict",_this.data.open_dict);
    }
    let open_dct=_this.data.open_dict;
    let sort_lst=[];//要排序的列表
    let sort_dct={};
    let father_dom__=_this.$refs.father;
    let father_dom=_this.data.fast_data[path];
    if(path!=''&&path!=null){
        ttime3(_this.data.fast_vue_data[path],'ref_obj',_this.data.set_open,func2_lst=[_this.data.fast_vue_data[path]]);//打开
    }
    // console.log("father_dom__",father_dom__)
    // 创建一个 DocumentFragment  
    // let fragment = document.createDocumentFragment();  
    // console.log("开始展开,展开路径:",path)
    //通过path解析路径
    let obj=_this.data.data;
    let path_lst=path.split(".");
    let space=(path_lst.length-1)*8;
    if (path==''){space=-8}
    // console.log("now space:",path_lst,space)
    if (path==''){path_lst=[]}
    for (let i=0;i<path_lst.length;i++){
        obj=obj.dict[path_lst[i]];
        open_dct=open_dct[path_lst[i]];
    
    }
    //打开当前dom
    open_dct.close=false;
    /*console.log("打开当前dom:",path)*/
    let lst=[{
                "path":path,//父节点的路径
                "insert_id":null,//要插入节点的节点id
                fast_obj:obj,//父节点的 的对象
                'space':space,//缩进位数
                'open_num':0,//当前展开层数
                'open_dct':open_dct
            }];
            // console.log("open 3")
    while (lst.length){
        let temp_lst=null;temp_lst_length=null;now_id=null;new_fast_obj=null;new_father_path=null;
        let new_dom=null;new_vue=null;t_deepcopy_data=null;new_fast_obj_base_info=null;vue_name=null;
        let lst_item=lst.pop();
        let new_path=lst_item['path'];//父节点key 用于获取父节点dom
        let fast_obj=lst_item['fast_obj'];//当前节点的dict
        let now_dict=fast_obj.dict;//当前节点下的子节点的dicts
        let insert_id=lst_item['insert_id'];
        let now_open_num=lst_item['open_num'];//当前展开层数
        let now_open_dct=lst_item['open_dct'];
        // console.log("open 4")
        //将当前节点 插入dom中
        if (insert_id==null ){//如果是要展开的节点 那么不创建dom，仅赋值变量
            // console.log("open 5-1")
            if(path==''){
                //父节点快速查找路径
                new_father_path=null;}
            else{new_father_path=path}
            // console.log("open 5-12")
            new_fast_obj=fast_obj;
        }
        else{
            // console.log("open 5-2")
            new_fast_obj=now_dict[insert_id];
            new_fast_obj_base_info=new_fast_obj.base_info;
            // console.log("open 5-22")
            if (new_fast_obj_base_info){
                vue_name=new_fast_obj_base_info.vue_name||'a_1_0_2_0_0_lines';//要渲染的vue模板名称
                t_deepcopy_data=JSON.parse(JSON.stringify(new_fast_obj_base_info.deepcopy_data))||{};
            }else{
                vue_name="a_1_0_2_0_0_lines";
                t_deepcopy_data={};
            }
            // console.log("open 5-23")
            //获取当前节点
            if(new_path==null){
                // if (path==null){
                //     new_father_path=insert_id+'';
                // }else{
                    new_father_path=insert_id+'';
                // }
            }else{
                new_father_path=new_path+'.'+insert_id;
            }

            //新建一个dom
            new_dom=document.createElement(vue_name);
            //设置dom属性 ref值为ref_obj
            new_dom.setAttribute('ref', 'ref_obj');
            t_deepcopy_data['_space_']=lst_item.space;//退格
            t_deepcopy_data['path']=new_father_path;
            t_deepcopy_data['tree_data']=_this.data.tree_data;
            
            /*console.log("??????t_deepcopy_data",t_deepcopy_data,_this.data.tree_data)*/
            t_deepcopy_data['click_handle']=_this.data.click_handle;
            new_dom.setAttribute(':deepcopy_data',"deepcopy_data");//初始化vue模板的参数
            new_dom.setAttribute('dom_path',new_father_path);//初始化vue模板的参数

            sort_lst.push(new_father_path);
            sort_dct[new_father_path]={'el':new_dom,data:{true:true,false:false,null:null,deepcopy_data:t_deepcopy_data}}
            //检查当前节点是否处于展开状态 如果未展开 则跳过添加子节点
            if(now_open_dct.close==false){
                // console.log("flase?:",new_father_path,now_open_dct)
                t_deepcopy_data['close']=false;
            }
        }

        //检查当前节点是否处于展开状态 如果未展开 则跳过添加子节点
        if(now_open_dct.close==true){continue}
        // // if ()
        // //如果当前达到展开上限 则停止展开后续的子节点
        // if (now_open_num>=max_open_type){
        //     continue
        // }else{//设置为展开状态
        //     _this.data.fast_vue_data[new_father_path];
        //     if(new_father_path!=null){
        //         // console.log("_this.data.fast_vue_data[new_father_path],",_this.data.fast_vue_data[new_father_path],_this.data.fast_vue_data)
        //         ttime3(_this.data.fast_vue_data[new_father_path],'ref_obj',_this.data.set_open,func2_lst=[_this.data.fast_vue_data[new_father_path]]);//打开

        //     }
        // }
        // console.log("fast_obj.dict && Object.keys(fast_obj.dict).length",fast_obj.dict && Object.keys(fast_obj.dict).length,fast_obj.dict)

        //遍历子节点 将子节点添加进待处理队列中new_fast_obj
        if (new_fast_obj.dict && Object.keys(new_fast_obj.dict).length){
            // temp_lst=(Object.keys(fast_obj.dict).map(Number)).sort((a,b)=>b-a);
            temp_lst=(Object.keys(new_fast_obj.dict).map(Number)).sort((a,b)=>b-a);
            // console.log("temp_lst",temp_lst)
            temp_lst_length=temp_lst.length;
            if (!temp_lst_length){continue}
        }else{continue}
        //遍历子节点 倒序添加进处理队列
        // for (let i=temp_lst_length-1;i>=0;i--){
        for (let i=0;i<temp_lst_length;i++){
            now_id=temp_lst[i];
            lst.push({
                path:new_father_path,
                insert_id:now_id,
                fast_obj:new_fast_obj,
                space:lst_item.space+8,
                'open_num':now_open_num+1,//当前展开层数
                open_dct:now_open_dct[now_id]
            })
        }
        // console.log("temp_lst加入队列中:",temp_lst,JSON.parse(JSON.stringify(lst)))


    }
    // sort_lst.sort();//排序 ['1.1', '1.1.1', '1.2', '2.1', '2.2']
    let sort_lst2=[];
    // let sort_lst2=sort_lst;
    // console.log("sort_lst",sort_lst)
    while (sort_lst.length){ sort_lst2.push(sort_lst.pop());}
    let count_max=40;count_start=0;
    let fragment = document.createDocumentFragment(); //创建虚拟节点
    let next_dom=father_dom;
    let next_dom2=father_dom;
    // console.log("sort_lst2",father_dom__,next_dom,sort_lst2)
    while (sort_lst2.length){
        //等待页面刷新完成
        if ((count_start++)%count_max==0){
            _this.insertAfter(fragment,next_dom,father_dom__);
            await _this.sleep(16);
            fragment = document.createDocumentFragment(); //创建虚拟节点
            next_dom=next_dom2;
            // console.log("next_dom",next_dom)
            // father_dom__.appendChild(fragment);

        }
        let new_path=sort_lst2.pop();
        let vue_dct=sort_dct[new_path];
        // console.log("newpath",new_path,vue_dct)
        let new_dom=vue_dct.el;
        // _this.insertAfter(new_dom,fragment,fragment);
        fragment.appendChild(new_dom);
                //  father_dom__.appendChild(new_dom);
                 
                // _this.insertAfter(new_dom,father_dom,father_dom__);
        let new_vue=new Vue(vue_dct);
        // window.test_vue=new_vue;
        _this.data.fast_data[new_path]=new_vue.$el;
        next_dom2=new_vue.$el;
        _this.data.fast_vue_data[new_path]=new_vue;
    }
    
    _this.insertAfter(fragment,next_dom,father_dom__);
    // console.log("sort_lst",sort_lst);
    // console.log("...",fragment)
  }
  _this.data.open=async function(path){
    
    console.log("?13")
    _this.wait_run_func_class_obj.timer_start({
        func:_this.data._open,
        params:path
    })
    
    console.log("?23")
  }
  _this.data._close=async function(path){

    // parent.removeChild(nodeA.nextSibling); // 这里直接删除也可以，但为演示添加到数组后再删除  
    let test_count1=0;
    let open_dct=_this.data.open_dict;
    let sort_lst=[];//要排序的列表
    let sort_dct={};
    let father_dom__=_this.$refs.father;
    let father_dom=_this.data.fast_data[path];
    // console.log("father_dom__",father_dom__)
    // 创建一个 DocumentFragment  
    // let fragment = document.createDocumentFragment();  
    // console.log("开始展开,展开路径:",path)
    //通过path解析路径
    let obj=_this.data.data;
    let path_lst=path.split(".");
    let space=(path_lst.length-1)*8;
    if (path==''){space=-8}
    // console.log("now space:",path_lst,space)
    if (path==''){path_lst=[]}
    for (let i=0;i<path_lst.length;i++){
        obj=obj.dict[path_lst[i]];
        open_dct=open_dct[path_lst[i]];
    
    }
    let lst=[{
                "path":path,//父节点的路径
                "insert_id":null,//要插入节点的节点id
                fast_obj:obj,//父节点的 的对象
                'space':space,//缩进位数
                'open_num':0,//当前展开层数
                'open_dct':open_dct
            }];
            // console.log("open 3")
    while (lst.length){
        let temp_lst=null;temp_lst_length=null;now_id=null;new_fast_obj=null;new_father_path=null;
        let new_dom=null;new_vue=null;t_deepcopy_data=null;new_fast_obj_base_info=null;vue_name=null;
        let lst_item=lst.pop();
        let new_path=lst_item['path'];//父节点key 用于获取父节点dom
        let fast_obj=lst_item['fast_obj'];//当前节点的dict
        let now_dict=fast_obj.dict;//当前节点下的子节点的dicts
        let insert_id=lst_item['insert_id'];
        let now_open_num=lst_item['open_num'];//当前展开层数
        let now_open_dct=lst_item['open_dct'];
        // console.log(lst_item,new_path,fast_obj,now_dict,insert_id,now_open_num,now_open_dct,'xxx')
        // console.log("open 4")
        //将当前节点 插入dom中
        if (insert_id==null ){//如果是要展开的节点 那么不创建dom，仅赋值变量
            // console.log("open 5-1")
            if(path==''){
                //父节点快速查找路径
                new_father_path=null;}
            else{new_father_path=path}
            // console.log("open 5-12")
            new_fast_obj=fast_obj;
        }
        else{
            // console.log("open 5-2")
            // console.log("new_path",new_path,insert_id)
            // console.log("new_fast_obj",now_dict,insert_id)
            new_fast_obj=now_dict[insert_id];
            new_fast_obj_base_info=new_fast_obj.base_info;
            // console.log("open 5-22")
            if (new_fast_obj_base_info){
                vue_name=new_fast_obj_base_info.vue_name||'a_1_0_2_0_0_lines';//要渲染的vue模板名称
                t_deepcopy_data=new_fast_obj_base_info.deepcopy_data||{};
            }else{
                vue_name="a_1_0_2_0_0_lines";
                t_deepcopy_data={};
            }
            // console.log("open 5-23")
            //获取当前节点
            if(new_path==null){
                // if (path==null){
                //     new_father_path=insert_id+'';
                // }else{
                    new_father_path=insert_id+'';
                // }
            }else{
                new_father_path=new_path+'.'+insert_id;
            }

            sort_lst.push(new_father_path);
        }

        //检查当前节点是否处于展开状态 如果未展开 则跳过添加子节点
        // console.log("now_open_dct",now_open_dct)
        console.log("new_path",new_path,now_open_dct)
        if(now_open_dct.close==true){continue}
        //遍历子节点 将子节点添加进待处理队列中
        if (new_fast_obj.dict && Object.keys(new_fast_obj.dict).length){
            // temp_lst=(Object.keys(fast_obj.dict).map(Number)).sort((a,b)=>b-a);
            temp_lst=(Object.keys(new_fast_obj.dict).map(Number)).sort((a,b)=>b-a);
            // console.log("temp_lst",temp_lst)
            temp_lst_length=temp_lst.length;
            if (!temp_lst_length){continue}
        }else{continue}
        // console.log("new_father_path add",new_father_path,temp_lst)
        //遍历子节点 倒序添加进处理队列
        // for (let i=temp_lst_length-1;i>=0;i--){
            test_count1=test_count1+temp_lst_length;
            console.log(`当前处理数量:${temp_lst_length}/${test_count1}`,temp_lst,new_fast_obj.dict)
        for (let i=0;i<temp_lst_length;i++){
            // console.log("添加入",now_open_dct,now_id,open_dct[now_id])
            now_id=temp_lst[i];
            lst.push({
                path:new_father_path,
                insert_id:now_id,
                fast_obj:new_fast_obj,
                'open_num':now_open_num+1,//当前展开层数
                open_dct:now_open_dct[now_id]
            })
        }
        // console.log("temp_lst加入队列中:",temp_lst,JSON.parse(JSON.stringify(lst)))


    }
    // console.log("del lst:",JSON.parse(JSON.stringify(sort_lst)))
    let count_max=2330;count_start=0;
    while (sort_lst.length){
        //等待页面刷新完成
        if ((count_start++)%count_max==0){
            await _this.sleep(20);
        }
        let new_path=sort_lst.pop();
        father_dom__.removeChild(_this.data.fast_data[new_path]);
        // array.splice(indexToRemove, 1);  
        delete _this.data.fast_data[new_path];  
        delete _this.data.fast_vue_data[new_path];  
    }
    
    //关闭当前dom
    open_dct.close=true;
    
    // console.log("关闭当前dom:")
    // console.log("close !",open_dct)
    if(path!=''&&path!=null){
        ttime3(_this.data.fast_vue_data[path],'ref_obj',_this.data.set_close,func2_lst=[_this.data.fast_vue_data[path]]);//打开
    }
  }

  _this.data.close=async function(path){
    
    console.log("?14")
    _this.wait_run_func_class_obj.timer_start({
        func:_this.data._close,
        params:path
    })
    console.log("?24")

  }
}
}
);
// 
